home *** CD-ROM | disk | FTP | other *** search
/ Aminet 37 / Aminet 37 (2000)(Schatztruhe)[!][Jun 2000].iso / Aminet / dev / lang / sofa.lha / sofa / smalleiffel / lib_se / call_infix2.e < prev    next >
Text File  |  2000-03-25  |  13KB  |  440 lines
  1. --          This file is part of SmallEiffel The GNU Eiffel Compiler.
  2. --          Copyright (C) 1994-98 LORIA - UHP - CRIN - INRIA - FRANCE
  3. --            Dominique COLNET and Suzanne COLLIN - colnet@loria.fr
  4. --                       http://SmallEiffel.loria.fr
  5. -- SmallEiffel is  free  software;  you can  redistribute it and/or modify it
  6. -- under the terms of the GNU General Public License as published by the Free
  7. -- Software  Foundation;  either  version  2, or (at your option)  any  later
  8. -- version. SmallEiffel is distributed in the hope that it will be useful,but
  9. -- WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  10. -- or  FITNESS FOR A PARTICULAR PURPOSE.   See the GNU General Public License
  11. -- for  more  details.  You  should  have  received a copy of the GNU General
  12. -- Public  License  along  with  SmallEiffel;  see the file COPYING.  If not,
  13. -- write to the  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  14. -- Boston, MA 02111-1307, USA.
  15. --
  16. deferred class CALL_INFIX2
  17.    --
  18.    -- Root for CALL_INFIX_EQ and CALL_INFIX_NEQ.
  19.    --
  20.  
  21. inherit CALL_INFIX redefine static_result_base_class, use_current end;
  22.  
  23. feature
  24.  
  25.    precedence: INTEGER is 6;
  26.  
  27.    left_brackets: BOOLEAN is false;
  28.  
  29. feature {NONE}
  30.  
  31.    frozen make(lp: like target; operator_position: POSITION; rp: like arg1) is
  32.       require
  33.          lp /= Void;
  34.          not operator_position.is_unknown;
  35.          rp /= Void
  36.       do
  37.          target := lp;
  38.          !!feature_name.make(operator,operator_position);
  39.          !!arguments.make_1(rp);
  40.       ensure
  41.          target = lp;
  42.          start_position = operator_position;
  43.          arguments.first = rp
  44.       end;
  45.  
  46.    frozen with(t: like target; fn: like feature_name; a: like arguments) is
  47.       require
  48.          t /= Void;
  49.          fn /= Void;
  50.          a.count = 1
  51.       do
  52.          target := t;
  53.          feature_name := fn;
  54.          arguments := a;
  55.       ensure
  56.          target = t;
  57.          feature_name = fn;
  58.          arguments = a
  59.       end;
  60.  
  61. feature
  62.  
  63.    frozen static_result_base_class: BASE_CLASS is
  64.       do
  65.          Result := small_eiffel.get_class(as_boolean);
  66.       end;
  67.  
  68.    frozen run_feature: RUN_FEATURE is
  69.       do
  70.       end;
  71.  
  72.    frozen result_type: TYPE is
  73.       do
  74.          Result := type_boolean;
  75.       end;
  76.  
  77.    frozen to_runnable(ct: TYPE): like Current is
  78.       require
  79.          ct /= Void
  80.       local
  81.          t: like target;
  82.          a: like arguments;
  83.       do
  84.          t := runnable_expression(target,ct);
  85.          a := runnable_args(arguments,ct);
  86.          if t = target and then a = arguments then
  87.             Result := Current;
  88.          else
  89.             !!Result.with(t,feature_name,a);
  90.          end;
  91.          Result.check_comparison(ct);
  92.       end;
  93.  
  94.    frozen assertion_check(tag: CHARACTER) is
  95.       do
  96.          target.assertion_check(tag);
  97.          arg1.assertion_check(tag);
  98.       end;
  99.  
  100.    frozen use_current: BOOLEAN is
  101.       do
  102.          Result := target.use_current or else arg1.use_current;
  103.       end;
  104.  
  105.    frozen isa_dca_inline_argument: INTEGER is
  106.       do
  107.       end;
  108.  
  109.    frozen dca_inline_argument(formal_arg_type: TYPE) is
  110.       do
  111.       end;
  112.  
  113. feature {RUN_FEATURE_4}
  114.  
  115.    frozen dca_inline(formal_arg_type: TYPE) is
  116.       do
  117.          cpp.put_character('(');
  118.          cpp.put_target_as_value;
  119.          cpp.put_character(')');
  120.          if operator.first = '=' then
  121.             cpp.put_string(fz_c_eq);
  122.          else
  123.             cpp.put_string(fz_c_neq);
  124.          end;
  125.          cpp.put_character('(');
  126.          arg1.dca_inline_argument(formal_arg_type);
  127.          cpp.put_character(')');
  128.       end;
  129.  
  130. feature {RUN_FEATURE_3,RUN_FEATURE_4}
  131.  
  132.    finalize is
  133.       do
  134.       end;
  135.  
  136. feature {CALL_INFIX2}
  137.  
  138.    frozen check_comparison(ct: TYPE) is
  139.       local
  140.          tt, at: TYPE;
  141.       do
  142.          if nb_errors = 0 then
  143.             tt := target.result_type.run_type;
  144.             at := arg1.result_type.run_type;
  145.             if tt.is_none then
  146.             elseif at.is_none then
  147.             elseif tt.is_reference then
  148.                if at.is_reference then
  149.                elseif not at.is_a(tt) then
  150.                   error_comparison("Reference/Expanded",ct);
  151.                end;
  152.             else
  153.                if at.is_expanded then
  154.                   if at.is_basic_eiffel_expanded then
  155.                      if tt.is_a(at) then
  156.                      else
  157.                         eh.cancel;
  158.                         if at.is_a(tt) then
  159.                         else
  160.                            error_comparison("Expanded/Expanded",ct);
  161.                         end;
  162.                      end;
  163.                   elseif tt.is_bit then
  164.                      bit_limitation(tt,at);
  165.                   elseif not at.is_a(tt) then
  166.                      error_comparison("Expanded/Expanded",ct);
  167.                   end;
  168.                elseif not tt.is_a(at) then
  169.                   error_comparison("Expanded/Reference",ct);
  170.                end;
  171.             end;
  172.          end;
  173. -- *** May be useful ??
  174. -- ***   if nb_errors = 0 then
  175. -- ***      if target.is_void then 
  176. -- ***         void_with_expanded_comparison_warning(arg1);
  177. -- ***      elseif arg1.is_void then
  178. -- ***         void_with_expanded_comparison_warning(target);
  179. -- ***      end;
  180. -- ***   end;
  181.       end;
  182.  
  183. feature {NONE}
  184.  
  185.    error_comparison(str: STRING; ct: TYPE) is
  186.       do
  187.          eh.add_position(feature_name.start_position);
  188.          eh.append(" Comparison ");
  189.          eh.append(str);
  190.          eh.append(" Not Valid. Context of Types interpretation is ");
  191.          eh.add_type(ct,fz_dot);
  192.          eh.print_as_fatal_error;
  193.       end;
  194.  
  195.    void_with_expanded_comparison_warning(e: EXPRESSION) is
  196.       local
  197.          rt: TYPE;
  198.          do_warning: BOOLEAN;
  199.       do
  200.          rt := e.result_type;
  201.          if rt.is_expanded then
  202.             do_warning := true;
  203.             if do_warning then
  204.                eh.append("Strange comparison of an expanded with Void %
  205.                          %(an expanded type is never Void).");
  206.                eh.add_position(e.start_position);
  207.                eh.print_as_warning;
  208.             end;
  209.          end;
  210.       end;
  211.  
  212.    bit_limitation(t1, t2: TYPE) is
  213.       require
  214.          t1.is_bit;
  215.          t2.is_bit
  216.       local
  217.          b1, b2: TYPE_BIT;
  218.       do
  219.          b1 ?= t1;
  220.          b2 ?= t2;
  221.          if b1.nb /= b2.nb then
  222.             eh.add_position(feature_name.start_position);
  223.             eh.append("Comparison between ");
  224.             eh.add_type(b1," and ");
  225.             eh.add_type(b2,
  226.             " is not yet implemented (you can work arround doing an %
  227.             %assignment in a local variable).");
  228.             eh.print_as_fatal_error;
  229.          end;
  230.       end;
  231.  
  232. feature {NONE}
  233.  
  234.    cmp_bit(equal_test: BOOLEAN; t: TYPE) is
  235.       require
  236.          t.is_bit
  237.       local
  238.          tb: TYPE_BIT;
  239.       do
  240.          tb ?= t;
  241.          if tb.is_c_unsigned_ptr then
  242.             if equal_test then
  243.                cpp.put_character('!');
  244.             end;
  245.             cpp.put_string("memcmp((");
  246.             target.mapping_c_target(t);
  247.             cpp.put_string(fz_20);
  248.             arg1.mapping_c_target(t);
  249.             cpp.put_string("),sizeof(T");
  250.             cpp.put_integer(tb.id);
  251.             cpp.put_string("))");
  252.          else
  253.             cpp.put_character('(');
  254.             target.compile_to_c;
  255.             cpp.put_character(')');
  256.             if equal_test then
  257.                cpp.put_string(fz_c_eq);
  258.             else
  259.                cpp.put_string(fz_c_neq);
  260.             end;
  261.             cpp.put_character('(');
  262.             arg1.compile_to_c;
  263.             cpp.put_character(')');
  264.          end;
  265.       end;
  266.  
  267.    cmp_user_expanded(equal_test: BOOLEAN; t: TYPE) is
  268.       require
  269.          t.is_user_expanded
  270.       local
  271.          mem_id: INTEGER;
  272.       do
  273.          if t.is_dummy_expanded then
  274.             cpp.put_character('(');
  275.             target.compile_to_c;
  276.             cpp.put_character(',');
  277.             arg1.compile_to_c;
  278.             cpp.put_character(',');
  279.             if equal_test then
  280.                cpp.put_character('1');
  281.             else
  282.                cpp.put_character('0');
  283.             end;
  284.             cpp.put_character(')');
  285.          else
  286.             mem_id := t.id;
  287.             if equal_test then
  288.                cpp.put_character('!');
  289.             end;
  290.             cpp.put_string(fz_se_cmpt);
  291.             cpp.put_integer(mem_id);
  292.             cpp.put_string(fz_17);
  293.             target.compile_to_c;
  294.             cpp.put_string(fz_20);
  295.             arg1.compile_to_c;
  296.             cpp.put_string(fz_13);
  297.          end;
  298.       end;
  299.  
  300.    cmp_basic_eiffel_expanded(equal_test: BOOLEAN; t1, t2: TYPE) is
  301.       require
  302.          t1.is_basic_eiffel_expanded;
  303.          t2.is_basic_eiffel_expanded
  304.       local
  305.          cast: STRING;
  306.       do
  307.      if t1.is_double or else t2.is_double then
  308.         cast := "((T5)(";
  309.      elseif t1.is_real or else t1.is_real then
  310.         cast := "((T4)(";
  311.      end;
  312.          if cast /= Void then
  313.             cpp.put_string(cast);
  314.          end;
  315.          cpp.put_character('(');
  316.          target.compile_to_c;
  317.          if cast /= Void then
  318.             cpp.put_string(fz_13);
  319.          end;
  320.          cpp.put_character(')');
  321.          if equal_test then
  322.             cpp.put_string(fz_c_eq);
  323.          else
  324.             cpp.put_string(fz_c_neq);
  325.          end;
  326.          cpp.put_character('(');
  327.          if cast /= Void then
  328.             cpp.put_string(cast);
  329.          end;
  330.          arg1.compile_to_c;
  331.          cpp.put_character(')');
  332.          if cast /= Void then
  333.             cpp.put_string(fz_13);
  334.          end;
  335.       end;
  336.  
  337.    cmp_basic_ref(equal_test: BOOLEAN) is
  338.          -- *** ORIGINAL ***
  339.       do
  340.          cpp.put_character('(');
  341.          target.compile_to_c;
  342.          cpp.put_character(')');
  343.          if equal_test then
  344.             cpp.put_string(fz_c_eq);
  345.          else
  346.             cpp.put_string(fz_c_neq);
  347.          end;
  348.          cpp.put_character('(');
  349.          cpp.put_string(fz_cast_void_star);
  350.          cpp.put_character('(');
  351.          arg1.compile_to_c;
  352.          cpp.put_character(')');
  353.          cpp.put_character(')');
  354.       end;
  355.  
  356.    ecoop99_1_cmp_basic_ref(equal_test: BOOLEAN) is
  357.          -- *** `cmp_basic_ref' for ECOOP'99 benchmark ***
  358.          -- *** With aliasing ***
  359.       local
  360.          string_cmp: BOOLEAN;
  361.       do
  362.          if target.result_type.run_type.is_string then
  363.             if arg1.result_type.run_type.is_string then
  364.                string_cmp := false;
  365.             end;
  366.          end;
  367.          if string_cmp then
  368.             if not equal_test then
  369.                cpp.put_string("(!(");
  370.             end;
  371.             cpp.put_string("/*ECOOP*/r7is_equal(((T7*)(");
  372.             target.compile_to_c;
  373.             cpp.put_string(")),((T0*)(");
  374.             arg1.compile_to_c;
  375.             cpp.put_string(")))");
  376.             if not equal_test then
  377.                cpp.put_string("))");
  378.             end;
  379.          else
  380.             cpp.put_character('(');
  381.             target.compile_to_c;
  382.             cpp.put_character(')');
  383.             if equal_test then
  384.                cpp.put_string(fz_c_eq);
  385.             else
  386.                cpp.put_string(fz_c_neq);
  387.             end;
  388.             cpp.put_character('(');
  389.             cpp.put_string(fz_cast_void_star);
  390.             cpp.put_character('(');
  391.             arg1.compile_to_c;
  392.             cpp.put_character(')');
  393.             cpp.put_character(')');
  394.          end;
  395.       end;
  396.  
  397.    ecoop99_2_cmp_basic_ref(equal_test: BOOLEAN) is
  398.          -- *** `cmp_basic_ref' for ECOOP'99 benchmark ***
  399.          -- *** Without aliasing ***
  400.       local
  401.          string_cmp: BOOLEAN;
  402.       do
  403.          if target.result_type.run_type.is_string then
  404.             if arg1.result_type.run_type.is_string then
  405.                string_cmp := true;
  406.             end;
  407.          end;
  408.          if string_cmp then
  409.             if not equal_test then
  410.                cpp.put_string("(!(");
  411.             end;
  412.             cpp.put_string("/*ECOOP*/r7is_equal(((T7*)(");
  413.             target.compile_to_c;
  414.             cpp.put_string(")),((T0*)(");
  415.             arg1.compile_to_c;
  416.             cpp.put_string(")))");
  417.             if not equal_test then
  418.                cpp.put_string("))");
  419.             end;
  420.          else
  421.             cpp.put_character('(');
  422.             target.compile_to_c;
  423.             cpp.put_character(')');
  424.             if equal_test then
  425.                cpp.put_string(fz_c_eq);
  426.             else
  427.                cpp.put_string(fz_c_neq);
  428.             end;
  429.             cpp.put_character('(');
  430.             cpp.put_string(fz_cast_void_star);
  431.             cpp.put_character('(');
  432.             arg1.compile_to_c;
  433.             cpp.put_character(')');
  434.             cpp.put_character(')');
  435.          end;
  436.       end;
  437.  
  438. end -- CALL_INFIX2
  439.  
  440.